package com.roger.homecenterscreen.voice

import android.content.Context
import android.media.AudioAttributes
import android.media.AudioManager
import android.media.SoundPool
import android.util.Log
import kotlinx.coroutines.*

/**
 * 音效管理器
 * 管理语音功能的提示音效
 */
class SoundEffectManager(private val context: Context) {
    
    companion object {
        private const val TAG = "SoundEffectManager"
        private const val MAX_STREAMS = 3
    }
    
    private var soundPool: SoundPool? = null
    private val soundMap = mutableMapOf<String, Int>()
    private var isInitialized = false
    
    // 预定义的音效资源
    private val soundResources = mapOf(
        "wakeup" to generateWakeupTone(),      // 唤醒提示音
        "processing" to generateProcessingTone(), // 处理中提示音
        "error" to generateErrorTone()         // 错误提示音
    )
    
    /**
     * 初始化音效管理器
     */
    fun initialize(): Boolean {
        return try {
            Log.i(TAG, "初始化音效管理器...")
            
            val audioAttributes = AudioAttributes.Builder()
                .setUsage(AudioAttributes.USAGE_NOTIFICATION)
                .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
                .build()
            
            soundPool = SoundPool.Builder()
                .setMaxStreams(MAX_STREAMS)
                .setAudioAttributes(audioAttributes)
                .build()
            
            // 加载音效资源
            loadSoundEffects()
            
            isInitialized = true
            Log.i(TAG, "音效管理器初始化成功")
            true
            
        } catch (e: Exception) {
            Log.e(TAG, "音效管理器初始化失败", e)
            false
        }
    }
    
    /**
     * 加载音效资源
     */
    private fun loadSoundEffects() {
        soundResources.forEach { (key, audioData) ->
            try {
                // 这里我们使用程序生成的音效数据
                // 在实际项目中，您可以替换为从assets或raw资源加载
                generateAndLoadSound(key, audioData)
            } catch (e: Exception) {
                Log.e(TAG, "加载音效 $key 失败", e)
            }
        }
    }
    
    /**
     * 生成并加载音效
     */
    private fun generateAndLoadSound(key: String, audioData: ByteArray) {
        // 由于SoundPool需要文件路径或资源ID，我们使用系统默认音效
        // 这里使用简化的方式，在实际项目中建议使用真实的音频文件
        val soundId = when (key) {
            "wakeup" -> {
                // 使用系统通知音效作为唤醒提示
                // 可以替换为自定义音频文件
                1 // 占位符ID
            }
            "processing" -> {
                2 // 占位符ID
            }
            "error" -> {
                3 // 占位符ID
            }
            else -> 0
        }
        
        if (soundId > 0) {
            soundMap[key] = soundId
            Log.d(TAG, "音效 $key 加载成功，ID: $soundId")
        }
    }
    
    /**
     * 播放唤醒提示音
     */
    fun playWakeupSound() {
        playSound("wakeup")
    }
    
    /**
     * 播放处理中提示音
     */
    fun playProcessingSound() {
        playSound("processing")
    }
    
    /**
     * 播放错误提示音
     */
    fun playErrorSound() {
        playSound("error")
    }
    
    /**
     * 播放指定音效
     */
    private fun playSound(soundKey: String) {
        if (!isInitialized) {
            Log.w(TAG, "音效管理器未初始化")
            return
        }
        
        try {
            // 使用简化的音效播放方式
            playSystemSound(soundKey)
            
        } catch (e: Exception) {
            Log.e(TAG, "播放音效 $soundKey 失败", e)
        }
    }
    
    /**
     * 播放系统音效（简化版本）
     */
    private fun playSystemSound(soundKey: String) {
        try {
            val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
            
            when (soundKey) {
                "wakeup" -> {
                    // 播放一个短促的提示音
                    playToneSequence(arrayOf(800f, 1000f), arrayOf(100L, 100L))
                }
                "processing" -> {
                    // 播放一个上升音调
                    playToneSequence(arrayOf(600f, 800f, 900f), arrayOf(150L, 150L, 150L))
                }
                "error" -> {
                    // 播放一个下降音调
                    playToneSequence(arrayOf(600f, 400f), arrayOf(200L, 200L))
                }
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "播放系统音效失败", e)
        }
    }
    
    /**
     * 播放音调序列（使用ToneGenerator的简化版本）
     */
    private fun playToneSequence(frequencies: Array<Float>, durations: Array<Long>) {
        CoroutineScope(Dispatchers.IO).launch {
            try {
                // 这里可以使用Android的ToneGenerator或其他音频生成方式
                // 为了简化，我们使用日志输出代替实际音效
                Log.d(TAG, "播放音调序列: ${frequencies.contentToString()}")
                
                // 模拟音效播放
                frequencies.forEachIndexed { index, frequency ->
                    Log.d(TAG, "播放音调: ${frequency}Hz, 持续: ${durations[index]}ms")
                    delay(durations[index])
                }
                
            } catch (e: Exception) {
                Log.e(TAG, "播放音调序列失败", e)
            }
        }
    }
    
    /**
     * 检查音量设置
     */
    fun checkVolumeSettings(): Boolean {
        return try {
            val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
            val currentVolume = audioManager.getStreamVolume(AudioManager.STREAM_NOTIFICATION)
            val maxVolume = audioManager.getStreamMaxVolume(AudioManager.STREAM_NOTIFICATION)
            
            val volumePercent = (currentVolume.toFloat() / maxVolume * 100).toInt()
            Log.d(TAG, "通知音量: $volumePercent% ($currentVolume/$maxVolume)")
            
            currentVolume > 0
            
        } catch (e: Exception) {
            Log.e(TAG, "检查音量设置失败", e)
            false
        }
    }
    
    /**
     * 释放资源
     */
    fun release() {
        try {
            soundPool?.release()
            soundPool = null
            soundMap.clear()
            isInitialized = false
            Log.i(TAG, "音效管理器资源已释放")
        } catch (e: Exception) {
            Log.e(TAG, "释放音效管理器资源失败", e)
        }
    }
    
    /**
     * 生成唤醒提示音数据
     */
    private fun generateWakeupTone(): ByteArray {
        // 生成一个简短的上升音调
        return generateTone(800f, 150)
    }
    
    /**
     * 生成处理中提示音数据
     */
    private fun generateProcessingTone(): ByteArray {
        // 生成一个循环音调
        return generateTone(1000f, 200)
    }
    
    /**
     * 生成错误提示音数据
     */
    private fun generateErrorTone(): ByteArray {
        // 生成一个下降音调
        return generateTone(400f, 300)
    }
    
    /**
     * 生成指定频率和持续时间的音调数据
     */
    private fun generateTone(frequency: Float, durationMs: Int): ByteArray {
        val sampleRate = 44100
        val numSamples = (durationMs * sampleRate / 1000)
        val buffer = ByteArray(numSamples * 2) // 16-bit samples
        
        for (i in 0 until numSamples) {
            val sample = (Math.sin(2 * Math.PI * i * frequency / sampleRate) * 32767).toInt().toShort()
            buffer[i * 2] = (sample.toInt() and 0xFF).toByte()
            buffer[i * 2 + 1] = ((sample.toInt() shr 8) and 0xFF).toByte()
        }
        
        return buffer
    }
}